// DeepSeek 平台适配器

class DeepSeekCollector extends DataCollector {
  constructor() {
    super('DeepSeek');
    
    // DeepSeek 特定的选择器
    // 注意：DeepSeek使用动态class名，使用属性选择器更稳定
    // 发送按钮是 div[role="button"]，不是 button 元素！
    this.selectors = {
      chatContainer: 'main',  // 主容器
      userMessage: '[class*="ds-message"]',  // 所有消息（用户+AI）
      aiMessage: '[class*="ds-message"]',    // 所有消息（用户+AI）
      inputBox: 'textarea',  // 输入框
      sendButton: 'div[role="button"][aria-disabled="false"]',  // 发送按钮（div实现）
      sendButtonIcon: '.ds-icon',  // 发送按钮内的图标
      loginButton: '.login-btn, button[href*="login"]',
      userAvatar: 'textarea',  // 如果输入框存在，说明已登录
      // 🔧 修复：DeepSeek 的"正在生成"标志
      // DeepSeek 可能没有明显的 generating 类名，主要依赖内容稳定性判断
      generating: '.streaming, .generating',  // 简化，主要依赖内容稳定性
      // 🔧 新增：回答完成的标志（操作按钮区域）
      messageActions: '.ds-icon-button'  // 回答完成后会显示操作按钮
    };
    
    // 🔧 新增：记录发送前的状态
    this.messageIndexBeforeSend = -1;  // 发送前最后一条AI消息的全局索引
    this.currentSendingQuestion = '';  // 🔧 新增：当前正在发送的问句内容
  }
  
  // 🔧 重写：记录发送消息前的AI消息数量
  recordAIMessageCountBeforeSend() {
    console.log('\n========== [DeepSeek] 📍 记录发送前状态 ==========');
    
    const allMessages = Array.from(document.querySelectorAll('.ds-message'));
    console.log('[DeepSeek] 当前页面所有消息数量:', allMessages.length);
    
    // 列出所有消息的详情
    allMessages.forEach((msg, idx) => {
      const hasMarkdown = msg.querySelector('.ds-markdown') !== null;
      const hasErrorContainer = msg.querySelector('[class*="_60a11b2"]') !== null;
      const isCollected = msg.dataset.collected === 'true';
      const preview = msg.textContent.substring(0, 30).replace(/\n/g, ' ');
      
      console.log(`[DeepSeek]   [${idx}] ${hasMarkdown ? 'AI正常' : hasErrorContainer ? 'AI错误' : '用户'} | 已采集:${isCollected ? '是' : '否'} | 内容: ${preview}...`);
    });
    
    // 找到最后一条AI消息的索引
    let lastAIIndex = -1;
    for (let i = allMessages.length - 1; i >= 0; i--) {
      const hasMarkdown = allMessages[i].querySelector('.ds-markdown') !== null;
      const hasErrorContainer = allMessages[i].querySelector('[class*="_60a11b2"]') !== null;
      
      if (hasMarkdown || hasErrorContainer) {
        lastAIIndex = i;
        console.log(`[DeepSeek] 📍 找到最后一条AI消息：索引=${i}`);
        break;
      }
    }
    
    this.messageIndexBeforeSend = lastAIIndex;
    this.aiMessageCountBeforeSend = allMessages.length;
    
    console.log(`[DeepSeek] 📍 记录完成：messageIndexBeforeSend=${this.messageIndexBeforeSend}`);
    console.log('[DeepSeek] ===========================================\n');
  }
  
  // 🔧 新增：设置当前正在发送的问句（在 sendMessage 中调用）
  setCurrentSendingQuestion(question) {
    this.currentSendingQuestion = question;
    console.log(`[DeepSeek] 📝 记录当前发送的问句: ${question.substring(0, 50)}...`);
  }

  // 获取目标节点
  getTargetNode() {
    return document.querySelector(this.selectors.chatContainer) || document.body;
  }

  // 处理DOM变化
  handleDOMChange(mutations) {
    if (!this.isCollecting) return;

    // 检查是否有新的AI消息（包含.ds-markdown的消息或错误消息）
    for (const mutation of mutations) {
      for (const node of mutation.addedNodes) {
        if (node.nodeType === 1) { // Element节点
          
          // 方法1：检查节点本身是否是 ds-message
          if (node.matches && node.matches('.ds-message')) {
            // 检查是否已采集
            if (node.dataset.collected === 'true') {
              continue;
            }
            
            // 检查是否包含 .ds-markdown（AI正常消息）
            const hasMarkdown = node.querySelector('.ds-markdown') !== null;
            // 🔧 检查是否包含错误消息
            const hasErrorContainer = node.querySelector('[class*="_60a11b2"]') !== null;
            const errorText = node.querySelector('[class*="_1ce76f5"]');
            const isErrorMessage = hasErrorContainer || (errorText && (
              errorText.textContent.includes('服务器繁忙') ||
              errorText.textContent.includes('请稍后') ||
              errorText.textContent.includes('重试') ||
              errorText.textContent.includes('错误')
            ));
            
            if (hasMarkdown || isErrorMessage) {
              // 立即设置标记，防止重复
              node.dataset.collected = 'true';
              
              const messageType = isErrorMessage ? '错误消息' : '正常消息';
              console.log(`[DeepSeek] DOM变化：检测到新的AI消息(${messageType})（直接节点）`);
              this.handleNewAIMessage(node);
              return;
            }
          }
          
          // 方法2：检查子节点中是否有 ds-message
          const messages = node.querySelectorAll?.('.ds-message');
          if (messages && messages.length > 0) {
            // 找到包含 .ds-markdown 或错误容器的消息（AI消息）
            for (const msg of messages) {
              if (msg.dataset.collected === 'true') {
                continue;
              }
              
              const hasMarkdown = msg.querySelector('.ds-markdown') !== null;
              const hasErrorContainer = msg.querySelector('[class*="_60a11b2"]') !== null;
              
              if (hasMarkdown || hasErrorContainer) {
                // 立即设置标记，防止重复
                msg.dataset.collected = 'true';
                
                const messageType = hasErrorContainer ? '错误消息' : '正常消息';
                console.log(`[DeepSeek] DOM变化：检测到新的AI消息(${messageType})（子节点）`);
                this.handleNewAIMessage(msg);
                return;
              }
            }
          }
          
          // 方法3：检查是否添加了 .ds-markdown 内容（消息更新）
          if (node.matches && node.matches('.ds-markdown')) {
            // 找到父级的 ds-message
            const messageParent = node.closest('.ds-message');
            if (messageParent) {
              // 立即设置标记，防止重复
              if (messageParent.dataset.collected === 'true') {
                continue;
              }
              messageParent.dataset.collected = 'true';
              
              console.log('[DeepSeek] DOM变化：检测到markdown内容更新');
              this.handleNewAIMessage(messageParent);
              return;
            }
          }
          
          // 🔧 方法4：检查是否添加了错误容器
          if (node.matches && node.matches('[class*="_60a11b2"]')) {
            // 找到父级的 ds-message
            const messageParent = node.closest('.ds-message');
            if (messageParent) {
              if (messageParent.dataset.collected === 'true') {
                continue;
              }
              messageParent.dataset.collected = 'true';
              
              console.log('[DeepSeek] DOM变化：检测到错误消息');
              this.handleNewAIMessage(messageParent);
              return;
            }
          }
        }
      }
    }
  }

  // 处理新的AI消息
  async handleNewAIMessage(element) {
    console.log('\n========== [DeepSeek] 处理新的AI消息（自动采集） ==========');
    console.log('[DeepSeek] 🔍 当前是否任务采集模式:', this.currentTaskId > 0 ? `是(taskId=${this.currentTaskId})` : '否');
    console.log('[DeepSeek] 🔍 自动采集状态:', this.isCollecting ? '开启' : '关闭');
    
    // 🔧 如果是任务采集模式，不应该进入这里（应该已经被stopCollecting停止了）
    if (this.currentTaskId > 0) {
      console.warn('[DeepSeek] ⚠️⚠️⚠️ 警告：任务采集模式下触发了自动采集！');
      console.warn('[DeepSeek] 这可能导致重复采集，跳过处理');
      return;
    }
    
    // 检查是否已标记
    if (element.dataset.collected === 'true') {
      console.log('[DeepSeek] ⚠️ 消息已被标记为已采集，跳过处理');
      return;
    }
    
    // 立即标记，防止重复处理
    element.dataset.collected = 'true';
    console.log('[DeepSeek] ✓ 已标记消息为已采集');

    const preview = element.textContent.substring(0, 50).replace(/\n/g, ' ').trim();
    console.log('[DeepSeek] 消息预览:', preview + '...');

    // 等待消息完成（检查是否还在生成中）
    console.log('[DeepSeek] 等待消息生成完成...');
    await this.waitForMessageComplete(element);

    console.log('[DeepSeek] AI消息已完成，开始提取数据');

    // 提取对话
    const conversation = this.extractConversation();
    if (conversation) {
      console.log('[DeepSeek] 数据提取成功，准备保存');
      console.log('[DeepSeek] 用户问题:', conversation.userMessage);
      console.log('[DeepSeek] AI回答长度:', conversation.aiResponse ? conversation.aiResponse.length : 0);
      console.log('[DeepSeek] 是否错误:', conversation.isError ? '是⚠️' : '否✅');
      await this.saveData(conversation);
      console.log('[DeepSeek] 数据保存完成');
    } else {
      console.warn('[DeepSeek] 数据提取失败，跳过保存');
    }
    
    console.log('[DeepSeek] ========== 处理完成 ==========\n');
  }

  // 等待消息完成（智能等待流式生成结束）
  async waitForMessageComplete(element, maxWait = 180000) {  // 最大等待3分钟
    const startTime = Date.now();
    
    console.log('[DeepSeek] 开始等待消息生成完成...');
    console.log('[DeepSeek] ⏰ 最大等待时间: 3分钟（180秒）');
    
    // 从设置读取等待时间（秒）
    const waitSeconds = this.settings?.stableWaitTime || 2;
    const requiredStableChecks = waitSeconds * 2; // 每0.5秒检查一次，所以乘以2
    
    console.log(`[DeepSeek] 配置：内容稳定 ${waitSeconds} 秒后采集`);
    
    return new Promise((resolve) => {
      let lastContent = '';
      let stableCount = 0;
      let hasSeenContent = false;  // 🔧 新增：是否曾经看到过内容
      
      const checkInterval = setInterval(() => {
        const elapsed = Date.now() - startTime;
        const elapsedSeconds = Math.floor(elapsed / 1000);
        
        // 每10秒打印一次进度
        if (elapsedSeconds > 0 && elapsedSeconds % 10 === 0 && elapsed % 1000 < 500) {
          console.log(`[DeepSeek] ⏰ 已等待 ${elapsedSeconds} 秒，剩余 ${Math.floor((maxWait - elapsed) / 1000)} 秒`);
        }
        
        // 🔧 方法1：检查输入框是否被禁用（DeepSeek在生成时会禁用输入框）
        const inputBox = document.querySelector(this.selectors.inputBox);
        const inputDisabled = inputBox && (inputBox.disabled || inputBox.getAttribute('aria-disabled') === 'true');
        
        // 🔧 方法2：检查发送按钮是否被禁用
        const sendButtons = document.querySelectorAll('div[role="button"]');
        let sendButtonDisabled = false;
        for (const btn of sendButtons) {
          const hasUpArrow = btn.querySelector('svg path[d*="M8.3"]');
          if (hasUpArrow) {
            sendButtonDisabled = btn.getAttribute('aria-disabled') === 'true';
            break;
          }
        }
        
        // 🔧 方法3：检查是否有操作按钮（复制、重新生成等）
        const hasActionButtons = element.querySelector(this.selectors.messageActions) !== null;
        
        // 🔧 方法4：检查内容是否还在变化（最可靠）
        const currentContent = this.extractMessageContent(element);
        const contentStable = currentContent === lastContent;
        
        // 记录是否曾经有过内容
        if (currentContent.length > 0) {
          hasSeenContent = true;
        }
        
        // 🔧 检查是否是错误消息（避免误判正常回答为错误）
        const isErrorResponse = (
          currentContent.includes('服务器繁忙') ||
          currentContent.includes('请稍后') ||
          currentContent.includes('重试') ||
          currentContent.includes('错误') ||
          currentContent.includes('网络异常') ||
          currentContent.includes('服务异常') ||
          currentContent.includes('暂时无法') ||
          currentContent.includes('请稍候') ||
          currentContent.includes('系统繁忙')
        );
        
        if (contentStable) {
          stableCount++;
          console.log(`[DeepSeek] 内容稳定计数: ${stableCount}/${requiredStableChecks} (长度: ${currentContent.length})`);
        } else {
          stableCount = 0;
          lastContent = currentContent;
          console.log('[DeepSeek] 内容还在变化，长度:', currentContent.length);
        }
        
        // 🔧 综合判断是否正在生成
        const isGenerating = inputDisabled || sendButtonDisabled;
        
        if (isGenerating) {
          console.log(`[DeepSeek] 检测到正在生成中... (输入框禁用:${inputDisabled}, 发送按钮禁用:${sendButtonDisabled})`);
        }
        
        // 🔧 判断完成的多重条件
        const conditions = {
          contentStable: stableCount >= requiredStableChecks,
          notGenerating: !isGenerating,
          hasContent: currentContent.length > 0,
          hasActions: hasActionButtons,
          timeout: elapsed > maxWait
        };
        
        console.log('[DeepSeek] 完成条件检查:', {
          '内容稳定': conditions.contentStable ? '✅' : '❌',
          '未在生成': conditions.notGenerating ? '✅' : '❌',
          '有内容': conditions.hasContent ? '✅' : '❌',
          '有操作按钮': conditions.hasActions ? '✅' : '❌',
          '是错误消息': isErrorResponse ? '⚠️' : '正常',
          '已超时': conditions.timeout ? '⚠️' : '正常'
        });
        
        // 🔧 完成条件（任一满足即可）：
        // 条件A：内容稳定 且 未在生成 且 有内容
        // 条件B：内容稳定 且 有操作按钮 且 有内容
        // 条件C：超时（但必须有内容）
        
        const conditionA = conditions.contentStable && conditions.notGenerating && conditions.hasContent;
        const conditionB = conditions.contentStable && conditions.hasActions && conditions.hasContent;
        const conditionC = conditions.timeout && hasSeenContent;
        
        if (conditionA || conditionB) {
          clearInterval(checkInterval);
          const totalSeconds = Math.floor(elapsed / 1000);
          console.log(`[DeepSeek] ✅ 消息生成完成！用时: ${totalSeconds}秒，长度: ${currentContent.length}字符`);
          console.log(`[DeepSeek] 完成原因: ${conditionA ? '条件A(稳定+未生成)' : '条件B(稳定+有按钮)'}`);
          resolve();
        } else if (conditionC) {
          clearInterval(checkInterval);
          const totalSeconds = Math.floor(elapsed / 1000);
          console.warn(`[DeepSeek] ⚠️ 等待超时（${totalSeconds}秒），强制采集`);
          console.warn('[DeepSeek] 当前内容长度:', currentContent.length);
          
          if (currentContent.length === 0) {
            console.error('[DeepSeek] ❌ 超时且无内容，采集失败');
          }
          resolve();
        }
      }, 500); // 每500ms检查一次
    });
  }

  // 提取对话数据
  extractConversation() {
    try {
      console.log('\n========== [DeepSeek] 开始提取对话数据 ==========');
      console.log('[DeepSeek] 📍 发送前的AI消息索引:', this.messageIndexBeforeSend);
      console.log('[DeepSeek] 📍 是否任务采集模式:', this.messageIndexBeforeSend >= 0 ? '是' : '否');
      
      // 🔧 使用稳定的特征来区分用户消息和AI消息
      const allMessages = Array.from(document.querySelectorAll('.ds-message'));
      console.log('[DeepSeek] 当前页面所有消息数量:', allMessages.length, '个');
      console.log('[DeepSeek] ----------------------------------------');
      
      if (allMessages.length < 1) {
        console.warn('[DeepSeek] 消息数量不足');
        return null;
      }
      
      // 分类消息：用户消息 vs AI消息（包括正常和错误）
      const userMessages = [];
      const aiMessages = [];
      
      console.log('[DeepSeek] 开始分类所有消息...');
      allMessages.forEach((msg, index) => {
        const hasMarkdown = msg.querySelector('.ds-markdown') !== null;
        const isCollected = msg.dataset.collected === 'true';
        
        // 🔧 检查是否是错误消息（DeepSeek特有）
        const hasErrorContainer = msg.querySelector('[class*="_60a11b2"]') !== null;
        const errorText = msg.querySelector('[class*="_1ce76f5"]');
        const msgContent = msg.textContent;
        const isErrorMessage = hasErrorContainer || (errorText && (
          errorText.textContent.includes('服务器繁忙') ||
          errorText.textContent.includes('请稍后') ||
          errorText.textContent.includes('重试') ||
          errorText.textContent.includes('错误') ||
          errorText.textContent.includes('网络异常') ||
          errorText.textContent.includes('服务异常') ||
          errorText.textContent.includes('暂时无法') ||
          errorText.textContent.includes('请稍候') ||
          errorText.textContent.includes('系统繁忙')
        )) || (
          msgContent.includes('服务器繁忙') ||
          msgContent.includes('请稍后') ||
          msgContent.includes('重试') ||
          msgContent.includes('错误') ||
          msgContent.includes('网络异常') ||
          msgContent.includes('服务异常') ||
          msgContent.includes('暂时无法') ||
          msgContent.includes('请稍候') ||
          msgContent.includes('系统繁忙')
        );
        
        const preview = msg.textContent.substring(0, 40).replace(/\n/g, ' ').trim();
        
        // AI消息：有 markdown 或 是错误消息
        if (hasMarkdown || isErrorMessage) {
          aiMessages.push({ 
            element: msg, 
            index, 
            isCollected,
            isError: isErrorMessage,
            hasMarkdown: hasMarkdown
          });
          
          const type = isErrorMessage ? 'AI错误' : 'AI正常';
          console.log(`[DeepSeek]   [${index}] ${type} | 已采集:${isCollected?'✅':'❌'} | 内容: ${preview}...`);
        } else {
          userMessages.push({ element: msg, index, isCollected });
          console.log(`[DeepSeek]   [${index}] 用户 | 已采集:${isCollected?'✅':'❌'} | 内容: ${preview}...`);
        }
      });
      
      console.log('[DeepSeek] ----------------------------------------');
      console.log('[DeepSeek] 分类结果：用户消息', userMessages.length, '个，AI消息', aiMessages.length, '个');
      console.log('[DeepSeek]   - AI消息中已采集:', aiMessages.filter(m => m.isCollected).length, '个');
      console.log('[DeepSeek]   - AI消息中错误:', aiMessages.filter(m => m.isError).length, '个');
      console.log('[DeepSeek] ----------------------------------------');
      
      // 🔧 关键修复：使用多策略查找目标AI消息
      let lastAiMessage = null;
      let selectionStrategy = '';
      
      // 🔧 策略0：如果有发送的问句内容，通过内容匹配找对应的回答（最可靠）⭐⭐⭐⭐⭐
      if (this.currentSendingQuestion) {
        console.log('[DeepSeek] 🎯 策略0：内容匹配模式 - 查找对应问句的回答');
        console.log('[DeepSeek] 当前发送的问句:', this.currentSendingQuestion.substring(0, 50) + '...');
        
        // 找到包含这个问句的用户消息
        let targetUserMessage = null;
        for (let i = userMessages.length - 1; i >= 0; i--) {
          const userContent = this.extractMessageContent(userMessages[i].element);
          if (userContent === this.currentSendingQuestion) {
            targetUserMessage = userMessages[i];
            console.log(`[DeepSeek] ✓ 找到匹配的用户消息 (全局索引 ${userMessages[i].index})`);
            break;
          }
        }
        
        // 找到这个用户消息后面、最近的AI消息（包括未采集的）
        if (targetUserMessage) {
          // 🔧 修复：从后往前遍历，找到最新的AI消息
          console.log(`[DeepSeek] 开始查找用户消息[${targetUserMessage.index}]后面的AI消息...`);
          
          for (let i = aiMessages.length - 1; i >= 0; i--) {
            console.log(`[DeepSeek]   检查AI消息[${i}]: 全局索引=${aiMessages[i].index}, 是否>用户索引(${targetUserMessage.index}): ${aiMessages[i].index > targetUserMessage.index ? '是✅' : '否❌'}`);
            
            if (aiMessages[i].index > targetUserMessage.index) {
              // 🔧 进一步验证：确保这个AI消息确实是新的（不是之前已经采集过的）
              // 如果是任务采集模式，还需要检查是否真的是新增的AI消息
              if (this.messageIndexBeforeSend >= 0) {
                // 任务采集模式：确保AI消息索引大于发送前的索引
                if (aiMessages[i].index > this.messageIndexBeforeSend) {
                  lastAiMessage = aiMessages[i];
                  selectionStrategy = '策略0-内容匹配+索引验证';
                  const messageType = lastAiMessage.isError ? '错误消息' : '正常消息';
                  console.log(`[DeepSeek] ✅✅✅ 找到对应的AI消息(${messageType}) (数组索引 ${i}，全局索引 ${aiMessages[i].index})`);
                  console.log(`[DeepSeek] 该AI消息已采集状态: ${aiMessages[i].isCollected ? '是' : '否'}`);
                  console.log(`[DeepSeek] 索引验证通过: AI索引(${aiMessages[i].index}) > 用户索引(${targetUserMessage.index}) > 发送前索引(${this.messageIndexBeforeSend})`);
                  break;
                } else {
                  console.log(`[DeepSeek]   跳过：AI消息索引(${aiMessages[i].index}) <= 发送前索引(${this.messageIndexBeforeSend})`);
                }
              } else {
                // 自动采集模式：直接选择最新的AI消息
                lastAiMessage = aiMessages[i];
                selectionStrategy = '策略0-内容匹配';
                const messageType = lastAiMessage.isError ? '错误消息' : '正常消息';
                console.log(`[DeepSeek] ✅✅✅ 找到对应的AI消息(${messageType}) (数组索引 ${i}，全局索引 ${aiMessages[i].index})`);
                console.log(`[DeepSeek] 该AI消息已采集状态: ${aiMessages[i].isCollected ? '是' : '否'}`);
                break;
              }
            }
          }
          
          if (!lastAiMessage) {
            console.warn('[DeepSeek] ⚠️ 策略0失败：找到用户消息但没有对应的AI消息');
          }
        } else {
          console.warn('[DeepSeek] ⚠️ 策略0失败：没有找到匹配的用户消息');
        }
      }
      
      // 🔧 策略1：如果有发送前的索引记录，找索引更大的AI消息（任务采集模式）
      if (!lastAiMessage && this.messageIndexBeforeSend >= 0) {
        console.log('[DeepSeek] 🎯 策略1：索引比较模式 - 查找新增的AI消息（全局索引 > ' + this.messageIndexBeforeSend + '）');
        
        console.log('[DeepSeek] 开始遍历AI消息数组...');
        for (let i = aiMessages.length - 1; i >= 0; i--) {
          console.log(`[DeepSeek]   检查AI消息[${i}]: 全局索引=${aiMessages[i].index}, 是否>基准(${this.messageIndexBeforeSend}): ${aiMessages[i].index > this.messageIndexBeforeSend ? '是✅' : '否❌'}`);
          
          if (aiMessages[i].index > this.messageIndexBeforeSend) {
            lastAiMessage = aiMessages[i];
            selectionStrategy = '策略1-新增消息';
            const messageType = lastAiMessage.isError ? '错误消息' : '正常消息';
            console.log(`[DeepSeek] ✅✅✅ 找到新增的AI消息(${messageType}) (数组索引 ${i}，全局索引 ${aiMessages[i].index})`);
            
            // 🔧 延迟重置索引，避免影响下次
            console.log('[DeepSeek] 📍 将在采集成功后重置 messageIndexBeforeSend');
            break;
          }
        }
        
        if (!lastAiMessage) {
          console.warn('[DeepSeek] ⚠️ 策略1失败：没有找到索引更大的AI消息（可能因为DOM重组）');
          console.warn('[DeepSeek] 调试信息：');
          console.warn('[DeepSeek]   - 发送前索引:', this.messageIndexBeforeSend);
          console.warn('[DeepSeek]   - 当前AI消息索引:', aiMessages.map(m => m.index));
          console.warn('[DeepSeek]   - 页面总消息数:', allMessages.length);
          
          // 🔧 策略1.5：如果索引比较失败，尝试找最新的AI消息（按时间顺序）
          console.log('[DeepSeek] 🎯 策略1.5：时间顺序模式 - 查找最新的AI消息');
          if (aiMessages.length > 0) {
            // 找到索引最大的AI消息
            let latestAiMessage = aiMessages[0];
            console.log(`[DeepSeek] 开始查找最新AI消息，基准索引: ${this.messageIndexBeforeSend}`);
            
            for (let i = 1; i < aiMessages.length; i++) {
              console.log(`[DeepSeek]   比较AI消息[${i}]: 索引=${aiMessages[i].index} vs 当前最新=${latestAiMessage.index}`);
              if (aiMessages[i].index > latestAiMessage.index) {
                latestAiMessage = aiMessages[i];
                console.log(`[DeepSeek]   更新最新消息: 索引=${latestAiMessage.index}`);
              }
            }
            
            console.log(`[DeepSeek] 找到最新AI消息: 索引=${latestAiMessage.index}, 发送前索引=${this.messageIndexBeforeSend}`);
            
            // 🔧 修复：只有当最新的AI消息索引大于发送前的索引时，才认为是新的
            if (latestAiMessage.index > this.messageIndexBeforeSend) {
              lastAiMessage = latestAiMessage;
              selectionStrategy = '策略1.5-最新消息';
              const messageType = lastAiMessage.isError ? '错误消息' : '正常消息';
              console.log(`[DeepSeek] ✅✅✅ 找到最新的AI消息(${messageType}) (全局索引 ${latestAiMessage.index})`);
              console.log(`[DeepSeek] 验证通过: 最新索引(${latestAiMessage.index}) > 发送前索引(${this.messageIndexBeforeSend})`);
            } else {
              console.warn('[DeepSeek] ⚠️ 策略1.5失败：最新AI消息索引不大于发送前索引');
              console.warn(`[DeepSeek] 详细信息: 最新索引(${latestAiMessage.index}) <= 发送前索引(${this.messageIndexBeforeSend})`);
              console.warn('[DeepSeek] 这可能意味着AI回答还没有完全生成，或者DOM还没有更新');
            }
          }
        }
      } else {
        console.log('[DeepSeek] ℹ️ messageIndexBeforeSend < 0，跳过策略1');
      }
      
      // 🔧 策略2：如果没找到新增的，或不是任务采集模式，找最后一个未采集的（自动采集模式）
      if (!lastAiMessage) {
        console.log('[DeepSeek] 🎯 策略2：自动采集模式 - 查找最后一个未采集的AI消息');
        
        console.log('[DeepSeek] 开始遍历AI消息数组...');
        console.log(`[DeepSeek] 总AI消息数: ${aiMessages.length}`);
        
        for (let i = aiMessages.length - 1; i >= 0; i--) {
          const messageType = aiMessages[i].isError ? 'AI错误' : 'AI正常';
          console.log(`[DeepSeek]   检查AI消息[${i}]: 全局索引=${aiMessages[i].index}, 类型=${messageType}, 已采集:${aiMessages[i].isCollected?'是❌':'否✅'}`);
          
          if (!aiMessages[i].isCollected) {
            // 🔧 进一步验证：如果是任务采集模式，确保这个AI消息确实是新的
            if (this.messageIndexBeforeSend >= 0) {
              if (aiMessages[i].index > this.messageIndexBeforeSend) {
                lastAiMessage = aiMessages[i];
                selectionStrategy = '策略2-未采集+索引验证';
                console.log(`[DeepSeek] ✅✅✅ 找到未采集的AI消息(${messageType}) (数组索引 ${i}，全局索引 ${aiMessages[i].index})`);
                console.log(`[DeepSeek] 索引验证通过: AI索引(${aiMessages[i].index}) > 发送前索引(${this.messageIndexBeforeSend})`);
                break;
              } else {
                console.log(`[DeepSeek]   -> 跳过：AI消息索引(${aiMessages[i].index}) <= 发送前索引(${this.messageIndexBeforeSend})`);
              }
            } else {
              // 自动采集模式：直接选择未采集的AI消息
              lastAiMessage = aiMessages[i];
              selectionStrategy = '策略2-未采集';
              console.log(`[DeepSeek] ✅✅✅ 找到未采集的AI消息(${messageType}) (数组索引 ${i}，全局索引 ${aiMessages[i].index})`);
              console.warn('[DeepSeek] ⚠️ 警告：使用策略2可能选择了错误的消息，请检查消息对应关系');
              break;
            }
          } else {
            console.log(`[DeepSeek]   -> 已采集，跳过`);
          }
        }
        
        if (!lastAiMessage) {
          console.warn('[DeepSeek] ⚠️ 策略2失败：没有找到未采集的AI消息');
        }
      }
      
      if (!lastAiMessage) {
        console.error('[DeepSeek] ❌❌❌ 未找到目标AI消息（两个策略都失败）');
        console.error('[DeepSeek] 调试信息：');
        console.error('  - messageIndexBeforeSend:', this.messageIndexBeforeSend);
        console.error('  - AI消息总数:', aiMessages.length);
        console.error('  - AI消息详情:', aiMessages.map(m => `[${m.index}]已采集:${m.isCollected}`));
        return null;
      }
      
      console.log('[DeepSeek] ----------------------------------------');
      console.log('[DeepSeek] ✅ 选定AI消息：全局索引=' + lastAiMessage.index + ', 策略=' + selectionStrategy);
      console.log('[DeepSeek] ----------------------------------------');
      
      // 🔧 找到对应的用户消息
      // 策略：找到AI消息前面、最接近的用户消息
      let correspondingUserMessage = null;
      
      console.log('[DeepSeek] 查找对应的用户消息（全局索引 < ' + lastAiMessage.index + '）...');
      for (let i = userMessages.length - 1; i >= 0; i--) {
        console.log(`[DeepSeek]   检查用户消息[${i}]: 全局索引=${userMessages[i].index}, 是否<AI索引: ${userMessages[i].index < lastAiMessage.index ? '是✅' : '否❌'}`);
        
        // 用户消息的全局索引应该小于AI消息的全局索引
        if (userMessages[i].index < lastAiMessage.index) {
          correspondingUserMessage = userMessages[i];
          console.log(`[DeepSeek] ✅✅✅ 找到对应的用户消息 (数组索引 ${i}，全局索引 ${userMessages[i].index})`);
          break;
        }
      }
      
      if (!correspondingUserMessage) {
        console.warn('[DeepSeek] ⚠️ 未找到对应的用户消息');
        // 🔧 如果没有找到对应的用户消息，尝试使用最后一个用户消息
        if (userMessages.length > 0) {
          correspondingUserMessage = userMessages[userMessages.length - 1];
          console.log('[DeepSeek] ⚠️ 使用最后一个用户消息作为备选');
        } else {
          console.error('[DeepSeek] ❌ 没有任何用户消息');
          return null;
        }
      }
      
      console.log('[DeepSeek] ========================================');
      
      // 提取内容
      console.log('[DeepSeek] 准备提取用户消息内容...');
      const userContent = this.extractMessageContent(correspondingUserMessage.element);
      console.log('[DeepSeek] ✅ 用户消息:', userContent);
      
      console.log('[DeepSeek] 准备提取AI消息内容...');
      const aiContent = this.extractMessageContent(lastAiMessage.element);
      console.log('[DeepSeek] ✅ AI回答（前100字符）:', aiContent.substring(0, 100));
      
      // 🔧 检查是否是错误回答
      const isErrorResponse = lastAiMessage.isError || 
                             aiContent.includes('服务器繁忙') ||
                             aiContent.includes('请稍后') ||
                             aiContent.includes('重试') ||
                             aiContent.includes('错误') ||
                             aiContent.includes('网络异常') ||
                             aiContent.includes('服务异常') ||
                             aiContent.includes('暂时无法') ||
                             aiContent.includes('请稍候') ||
                             aiContent.includes('系统繁忙');

      if (!userContent) {
        console.error('[DeepSeek] ❌ 用户消息为空');
        return null;
      }
      
      if (!aiContent) {
        console.error('[DeepSeek] ❌ AI回答为空');
        return null;
      }
      
      if (isErrorResponse) {
        console.warn('[DeepSeek] ⚠️⚠️⚠️ 这是一个错误回答:', aiContent);
      } else {
        console.log('[DeepSeek] ✅ 这是一个正常回答');
      }
      
      console.log('[DeepSeek] ========================================');
      console.log('[DeepSeek] 最终结果：');
      console.log('[DeepSeek]   用户问题:', userContent);
      console.log('[DeepSeek]   AI回答:', aiContent.substring(0, 100) + (aiContent.length > 100 ? '...' : ''));
      console.log('[DeepSeek]   回答长度:', aiContent.length);
      console.log('[DeepSeek]   是否错误:', isErrorResponse ? '是⚠️' : '否✅');

      // 同时提取HTML格式
      const aiHTML = this.extractMessageHTML(lastAiMessage.element);
      
      // 🔧 成功提取后，清除状态变量（避免影响下次采集）
      if (this.currentSendingQuestion) {
        console.log('[DeepSeek] 📍 清除 currentSendingQuestion');
        this.currentSendingQuestion = '';
      }
      
      if (this.messageIndexBeforeSend >= 0) {
        console.log('[DeepSeek] 📍 重置 messageIndexBeforeSend = -1');
        this.messageIndexBeforeSend = -1;
      }
      
      console.log('[DeepSeek] ========== 对话数据提取完成 ==========\n');
      
      return {
        userMessage: userContent,
        aiResponse: aiContent,
        aiResponseHTML: aiHTML,  // 保留原始HTML格式
        isError: isErrorResponse,  // 🔧 新增：标记是否是错误回答
        errorMessage: isErrorResponse ? aiContent : null  // 🔧 新增：错误信息
      };
    } catch (e) {
      console.error('[DeepSeek] 提取对话失败:', e);
      console.error('[DeepSeek] 错误堆栈:', e.stack);
      return null;
    }
  }
  
  // 旧版提取方法（备用）
  extractConversationLegacy() {
    try {
      console.log('[DeepSeek] 使用旧版提取方法');
      
      // 获取所有消息（用户和AI的都是 ds-message）
      const allMessages = Array.from(document.querySelectorAll('[class*="ds-message"]'));
      
      if (allMessages.length < 2) {
        console.warn('[DeepSeek] 消息数量不足');
        return null;
      }

      console.log('[DeepSeek] 找到', allMessages.length, '条消息');

      // DeepSeek特征：AI消息包含 .ds-markdown，用户消息不包含
      // 找到最后一条**未采集过**的AI消息
      let lastAiMsg = null;
      let lastUserMsg = null;
      
      for (let i = allMessages.length - 1; i >= 0; i--) {
        const msg = allMessages[i];
        const hasMarkdown = msg.querySelector('.ds-markdown') !== null;
        
        // 跳过已经采集过的消息
        if (hasMarkdown && !lastAiMsg) {
          if (msg.dataset.collected === 'true') {
            console.log(`[DeepSeek] 跳过已采集的AI消息 (索引 ${i})`);
            continue;
          }
          lastAiMsg = msg;
          console.log(`[DeepSeek] ✓ 找到未采集的AI消息 (索引 ${i})`);
        } else if (!hasMarkdown && !lastUserMsg && lastAiMsg) {
          lastUserMsg = msg;
          console.log(`[DeepSeek] ✓ 找到对应的用户消息 (索引 ${i})`);
          break;
        }
      }
      
      if (!lastAiMsg || !lastUserMsg) {
        console.log('[DeepSeek] 使用默认策略：最后两条消息');
        lastUserMsg = allMessages[allMessages.length - 2];
        lastAiMsg = allMessages[allMessages.length - 1];
      }

      const userContent = this.extractMessageContent(lastUserMsg);
      const aiContent = this.extractMessageContent(lastAiMsg);

      if (!userContent || !aiContent) {
        console.warn('[DeepSeek] 内容为空');
        return null;
      }

      const aiHTML = this.extractMessageHTML(lastAiMsg);
      
      return {
        userMessage: userContent,
        aiResponse: aiContent,
        aiResponseHTML: aiHTML
      };
    } catch (e) {
      console.error('[DeepSeek] 旧版提取失败:', e);
      return null;
    }
  }
  
  // 提取消息内容（处理DeepSeek的特殊结构）
  extractMessageContent(messageElement) {
    if (!messageElement) return '';
    
    // 🔧 方法1：AI正常回答的消息内容在 .ds-markdown 容器中
    const markdownContent = messageElement.querySelector('.ds-markdown');
    if (markdownContent) {
      console.log('[DeepSeek] 从 .ds-markdown 提取内容（AI正常回答）');
      // 提取纯文本（移除HTML标签）
      return markdownContent.innerText || markdownContent.textContent || '';
    }
    
    // 🔧 方法2：AI错误回答在特定容器中（如：服务器繁忙）
    const errorContainer = messageElement.querySelector('[class*="_60a11b2"]');
    if (errorContainer) {
      const errorText = errorContainer.querySelector('[class*="_1ce76f5"]');
      if (errorText) {
        const errorContent = errorText.innerText || errorText.textContent || '';
        console.log('[DeepSeek] 从错误容器提取内容（AI错误回答）:', errorContent);
        return errorContent;
      }
      console.log('[DeepSeek] 从错误容器提取内容（AI错误回答）');
      return errorContainer.innerText || errorContainer.textContent || '';
    }
    
    // 🔧 方法3：用户问句在 class*="fbb" 容器中
    const userQuestionElement = messageElement.querySelector('[class*="fbb"]');
    if (userQuestionElement) {
      console.log('[DeepSeek] 从 [class*="fbb"] 提取内容（用户问句）');
      // 克隆并移除内部的按钮
      const cloned = userQuestionElement.cloneNode(true);
      const buttons = cloned.querySelectorAll('button, [role="button"], .ds-icon-button');
      buttons.forEach(btn => btn.remove());
      return cloned.innerText || cloned.textContent || '';
    }
    
    // 方法4：备用方案 - 使用整个元素的文本（但过滤掉按钮等）
    console.log('[DeepSeek] 使用备用方案提取内容');
    // 克隆元素避免修改原DOM
    const cloned = messageElement.cloneNode(true);
    // 移除按钮、图标等干扰元素
    const unwanted = cloned.querySelectorAll('button, [role="button"], .ds-icon-button, ._425ea0b, ._11d6b3a, ._0a3d93b');
    unwanted.forEach(el => el.remove());
    
    return cloned.innerText || cloned.textContent || '';
  }
  
  // 提取消息HTML格式（保留完整格式）
  extractMessageHTML(messageElement) {
    if (!messageElement) return '';
    
    // DeepSeek的消息内容在 .ds-markdown 容器中
    const markdownContent = messageElement.querySelector('.ds-markdown');
    
    if (markdownContent) {
      // 克隆元素，保留完整格式
      const cloned = markdownContent.cloneNode(true);
      
      // 可以在这里清理不需要的元素（如果有）
      // const unwanted = cloned.querySelectorAll('.unwanted-class');
      // unwanted.forEach(el => el.remove());
      
      // 返回HTML
      return cloned.innerHTML;
    }
    
    // 备用方案
    return messageElement.innerHTML || '';
  }

  // 提取文本内容（处理各种DOM结构）
  extractTextContent(element) {
    if (!element) return '';
    
    // 尝试多种方式提取文本
    return element.textContent?.trim() || 
           element.innerText?.trim() || 
           '';
  }

  // 发送消息
  async sendMessage(text) {
    try {
      console.log('\n========== [DeepSeek] 开始发送消息 ==========');
      console.log('[DeepSeek] 📨 消息内容:', text);
      console.log('[DeepSeek] 📨 消息长度:', text.length);
      console.log('[DeepSeek] 当前页面URL:', window.location.href);
      console.log('[DeepSeek] 页面是否可见:', document.visibilityState);
      
      // 🔧 记录当前发送的问句
      this.setCurrentSendingQuestion(text);
      
      // 1. 找到输入框
      console.log('[DeepSeek] 步骤1: 查找输入框');
      const inputBox = await this.waitForElement(this.selectors.inputBox);
      console.log('[DeepSeek] ✅ 找到输入框');
      console.log('[DeepSeek] 🔍 输入框当前值:', inputBox.value);
      console.log('[DeepSeek] 🔍 输入框value长度:', inputBox.value.length);
      console.log('[DeepSeek] 🔍 输入框是否禁用:', inputBox.disabled);
      console.log('[DeepSeek] 🔍 输入框aria-disabled:', inputBox.getAttribute('aria-disabled'));
      
      // 🔧 关键修复：多次清空，确保输入框完全清空
      console.log('[DeepSeek] 步骤2: 彻底清空输入框');
      for (let i = 0; i < 3; i++) {
        inputBox.value = '';
        inputBox.textContent = '';
        inputBox.innerText = '';
        
        // 触发清空事件
        ['input', 'change'].forEach(eventType => {
          const event = new Event(eventType, { bubbles: true, cancelable: true });
          inputBox.dispatchEvent(event);
        });
        
        console.log(`[DeepSeek]   清空尝试 ${i + 1}/3, 当前值长度: ${inputBox.value.length}`);
        
        if (i < 2) {
          await new Promise(resolve => setTimeout(resolve, 300));
        }
      }
      
      // 验证清空成功
      console.log('[DeepSeek] ✅ 清空完成，当前值:', inputBox.value === '' ? '(空)' : `"${inputBox.value}"`);
      
      // 聚焦输入框
      inputBox.focus();
      console.log('[DeepSeek] ✅ 输入框已聚焦');
      
      // 🔧 等待更长时间，确保DOM完全稳定
      console.log('[DeepSeek] 等待DOM稳定 (1000ms)...');
      await new Promise(resolve => setTimeout(resolve, 1000));
      
      // 3. 输入文本
      console.log('[DeepSeek] 步骤3: 输入文本');
      console.log('[DeepSeek] 🔍 即将输入的内容:', text);
      
      inputBox.value = text;
      
      // 触发所有必要的事件
      ['input', 'change', 'keyup'].forEach(eventType => {
        const event = new Event(eventType, { bubbles: true, cancelable: true });
        inputBox.dispatchEvent(event);
      });
      
      console.log('[DeepSeek] ✅ 文本已输入');
      console.log('[DeepSeek] 🔍 输入框最终值:', inputBox.value);
      console.log('[DeepSeek] 🔍 最终值长度:', inputBox.value.length);
      console.log('[DeepSeek] 🔍 是否匹配:', inputBox.value === text ? '✅ 匹配' : `❌ 不匹配! 预期"${text}", 实际"${inputBox.value}"`);
      
      // 🔧 等待UI更新
      console.log('[DeepSeek] 等待UI更新 (800ms)...');
      await new Promise(resolve => setTimeout(resolve, 800));
      
      // 4. 查找发送按钮（精确定位）
      console.log('[DeepSeek] 步骤4: 查找发送按钮');
      // DeepSeek的发送按钮特征：
      // - 是 div[role="button"]，不是 button 元素
      // - 在 input[type="file"] 的父容器内
      // - 包含向上箭头的SVG（path d="M8.3125..."）
      let sendButton = null;
      
      console.log('[DeepSeek] 查找发送按钮...');
      
      // 方法1：找到文件上传input，在其父容器中找发送按钮（最精确）
      const fileInput = document.querySelector('input[type="file"]');
      if (fileInput) {
        const fileContainer = fileInput.parentElement;
        console.log('[DeepSeek] 找到文件上传容器');
        
        // 在文件容器中查找包含向上箭头SVG的按钮
        const buttonsInFile = fileContainer.querySelectorAll('div[role="button"][aria-disabled="false"]');
        console.log('[DeepSeek] 文件容器中有', buttonsInFile.length, '个按钮');
        
        for (const btn of buttonsInFile) {
          // 查找包含特定路径的SVG（向上箭头）
          const svgPath = btn.querySelector('svg path[d^="M8.3"]');
          if (svgPath) {
            sendButton = btn;
            console.log('[DeepSeek] ✅ 找到发送按钮（向上箭头SVG）');
            break;
          }
        }
      }
      
      // 方法2：直接查找包含向上箭头SVG的div[role="button"]
      if (!sendButton) {
        console.log('[DeepSeek] 使用方法2：全局查找向上箭头按钮');
        const allRoleButtons = document.querySelectorAll('div[role="button"][aria-disabled="false"]');
        console.log('[DeepSeek] 找到', allRoleButtons.length, '个 role="button"');
        
        for (const btn of allRoleButtons) {
          // 检查SVG路径是否包含向上箭头的特征（M8.3125...）
          const svgPath = btn.querySelector('svg path[d*="M8.3"]');
          if (svgPath) {
            // 进一步验证：路径应该包含垂直移动（向上箭头）
            const pathD = svgPath.getAttribute('d');
            if (pathD && pathD.includes('V15') || pathD.includes('V3.95')) {
              sendButton = btn;
              console.log('[DeepSeek] ✅ 找到发送按钮（全局匹配）');
              break;
            }
          }
        }
      }
      
      // 方法3：根据按钮尺寸（发送按钮通常是 34x34）
      if (!sendButton) {
        console.log('[DeepSeek] 使用方法3：根据尺寸查找');
        const allRoleButtons = document.querySelectorAll('div[role="button"][aria-disabled="false"]');
        
        for (const btn of allRoleButtons) {
          const style = btn.getAttribute('style');
          if (style && style.includes('width: 34px') && style.includes('height: 34px')) {
            const svg = btn.querySelector('svg');
            if (svg) {
              sendButton = btn;
              console.log('[DeepSeek] ✅ 找到发送按钮（尺寸匹配）');
              break;
            }
          }
        }
      }
      
      if (!sendButton) {
        console.error('[DeepSeek] ❌ 未找到发送按钮');
        console.error('[DeepSeek] 文件上传元素:', fileInput);
        console.error('[DeepSeek] 页面所有 role="button":', document.querySelectorAll('div[role="button"]').length);
        console.error('[DeepSeek] 页面所有 aria-disabled="false":', document.querySelectorAll('[aria-disabled="false"]').length);
        throw new Error('未找到发送按钮');
      }
      
      console.log('[DeepSeek] ✅ 找到发送按钮:', sendButton);
      console.log('[DeepSeek] 按钮属性:', {
        role: sendButton.getAttribute('role'),
        ariaDisabled: sendButton.getAttribute('aria-disabled'),
        style: sendButton.getAttribute('style'),
        innerHTML: sendButton.innerHTML.substring(0, 100)
      });
      
      // 5. 点击发送按钮
      console.log('[DeepSeek] 步骤5: 点击发送按钮');
      console.log('[DeepSeek] 🔍 按钮 aria-disabled:', sendButton.getAttribute('aria-disabled'));
      
      // 🔧 只点击一次，避免重复发送
      sendButton.click();
      console.log('[DeepSeek] ✅ 已执行 click() 一次');
      
      // 🔧 不再触发额外的鼠标事件，避免重复发送
      // 旧代码会触发 mousedown, mouseup, click 共3次点击
      // 新代码只 click 一次
      
      console.log('[DeepSeek] ⏰ 等待消息发送完成 (1000ms)...');
      await new Promise(resolve => setTimeout(resolve, 1000));
      
      // 🔧 验证发送后的状态
      console.log('[DeepSeek] 🔍 发送后验证：');
      const inputBoxAfter = document.querySelector(this.selectors.inputBox);
      if (inputBoxAfter) {
        console.log('[DeepSeek] 🔍 输入框值:', inputBoxAfter.value === '' ? '(空✅)' : `"${inputBoxAfter.value}" ⚠️还有内容`);
        console.log('[DeepSeek] 🔍 输入框禁用:', inputBoxAfter.disabled || inputBoxAfter.getAttribute('aria-disabled') === 'true' ? '是（AI正在生成）' : '否');
      }
      
      console.log('[DeepSeek] ========== 消息发送完成 ==========\n');
    } catch (e) {
      console.error('[DeepSeek] 发送消息失败:', e);
      console.error('[DeepSeek] 错误堆栈:', e.stack);
      throw e;
    }
  }

  // 等待响应（用于sendMessage调用）
  async waitForResponse(timeout = 180000) {  // 最大等待3分钟
    const startTime = Date.now();
    
    console.log('[DeepSeek] 等待AI响应...');
    console.log('[DeepSeek] ⏰ 最大等待时间: 3分钟（180秒）');
    
    // 从设置读取等待时间
    const waitSeconds = this.settings?.stableWaitTime || 2;
    const requiredStableChecks = waitSeconds * 2; // 每0.5秒检查一次
    
    console.log(`[DeepSeek] 配置：内容稳定 ${waitSeconds} 秒后完成`);
    
    return new Promise((resolve, reject) => {
      let lastContent = '';
      let stableCount = 0;
      let hasSeenContent = false;  // 是否曾经看到过内容
      let lastMessageCount = 0;  // 🔧 新增：记录上次检查时的消息数量
      
      const checkInterval = setInterval(() => {
        const elapsed = Date.now() - startTime;
        const elapsedSeconds = Math.floor(elapsed / 1000);
        
        // 每15秒打印一次进度
        if (elapsedSeconds > 0 && elapsedSeconds % 15 === 0 && elapsed % 1000 < 500) {
          console.log(`[DeepSeek] ⏰ 已等待 ${elapsedSeconds} 秒，剩余 ${Math.floor((timeout - elapsed) / 1000)} 秒`);
        }
        
        // 获取所有消息
        const allMessages = document.querySelectorAll('.ds-message');
        const currentMessageCount = allMessages.length;
        
        // 🔧 关键修复：检查是否有新的消息出现
        if (currentMessageCount > lastMessageCount) {
          console.log(`[DeepSeek] 🎉 检测到新消息！消息数量从 ${lastMessageCount} 增加到 ${currentMessageCount}`);
          lastMessageCount = currentMessageCount;
          // 重置稳定计数，因为有了新内容
          stableCount = 0;
          lastContent = '';
        }
        
        if (allMessages.length === 0) {
          if (elapsedSeconds > 5) {
            console.warn('[DeepSeek] ⚠️ 等待超过5秒仍无消息...');
          }
          return;
        }
        
        // 🔧 找到最后一条AI消息（包括正常消息和错误消息）
        let lastAiMessage = null;
        for (let i = allMessages.length - 1; i >= 0; i--) {
          const hasMarkdown = allMessages[i].querySelector('.ds-markdown') !== null;
          const hasErrorContainer = allMessages[i].querySelector('[class*="_60a11b2"]') !== null;
          
          if (hasMarkdown || hasErrorContainer) {
            lastAiMessage = allMessages[i];
            if (hasErrorContainer) {
              console.log('[DeepSeek] 检测到AI错误消息');
            }
            break;
          }
        }
        
        // 🔧 关键修复：如果没有找到AI消息，说明AI回答还没有开始生成
        if (!lastAiMessage) {
          if (elapsedSeconds > 10) {
            console.warn('[DeepSeek] ⚠️ 等待超过10秒仍无AI消息出现...');
          }
          return;
        }
        
        // 检查内容是否稳定
        const currentContent = this.extractMessageContent(lastAiMessage);
        
        // 🔧 检查是否是错误消息（如：服务器繁忙）
        // 修复：错误消息检测应该更宽松，主要看关键词而不是长度
        const isErrorResponse = (
          currentContent.includes('服务器繁忙') ||
          currentContent.includes('请稍后') ||
          currentContent.includes('重试') ||
          currentContent.includes('错误') ||
          currentContent.includes('网络异常') ||
          currentContent.includes('服务异常') ||
          currentContent.includes('暂时无法') ||
          currentContent.includes('请稍候') ||
          currentContent.includes('系统繁忙')
        );
        
        // 记录是否曾经有过内容
        if (currentContent.length > 0) {
          hasSeenContent = true;
        }
        
        // 🔧 如果是错误消息，内容稳定后立即返回（只需1秒稳定即可）
        if (isErrorResponse && currentContent === lastContent && stableCount >= 2) {
          const totalSeconds = Math.floor(elapsed / 1000);
          console.warn(`[DeepSeek] ⚠️ 检测到错误响应（服务器繁忙等），用时: ${totalSeconds}秒`);
          console.warn(`[DeepSeek] 错误内容: ${currentContent}`);
          console.warn(`[DeepSeek] 注意：这是错误消息，不是正常的AI回答，将继续等待新的AI回答`);
          
          // 🔧 修复：错误消息不应该结束等待，应该继续等待新的AI回答
          // 但是为了不无限等待，我们设置一个较短的超时时间
          if (elapsed > 30000) { // 30秒后如果还是错误消息，就结束等待
            console.warn(`[DeepSeek] 错误消息等待超时，结束等待`);
            clearInterval(checkInterval);
            resolve();
            return;
          }
          // 继续等待新的AI回答，不结束循环
          return;
        }
        
        if (currentContent === lastContent) {
          stableCount++;
          console.log(`[DeepSeek] 响应内容稳定: ${stableCount}/${requiredStableChecks} (长度: ${currentContent.length})`);
        } else {
          stableCount = 0;
          lastContent = currentContent;
          console.log(`[DeepSeek] 响应内容更新: ${currentContent.length} 字符`);
        }
        
        // 检查输入框和发送按钮状态（判断是否还在生成）
        const inputBox2 = document.querySelector(this.selectors.inputBox);
        const isInputDisabled = inputBox2 && (inputBox2.disabled || inputBox2.getAttribute('aria-disabled') === 'true');
        
        // 检查是否有操作按钮（回答完成的标志）
        const hasActionButtons = lastAiMessage.querySelector(this.selectors.messageActions) !== null;
        
        console.log('[DeepSeek] 状态检查:', {
          '内容稳定': stableCount >= requiredStableChecks ? '✅' : `❌ (${stableCount}/${requiredStableChecks})`,
          '输入框禁用': isInputDisabled ? '🔴' : '✅',
          '有操作按钮': hasActionButtons ? '✅' : '❌',
          '是错误消息': isErrorResponse ? '⚠️' : '正常',
          '内容长度': currentContent.length
        });
        
        // 完成条件：
        // 条件A：内容稳定 且 输入框未禁用 且 有内容
        // 条件B：内容稳定 且 有操作按钮 且 有内容
        // 条件C：超时但有内容
        
        const conditionA = stableCount >= requiredStableChecks && !isInputDisabled && hasSeenContent;
        const conditionB = stableCount >= requiredStableChecks && hasActionButtons && hasSeenContent;
        const conditionC = elapsed > timeout && hasSeenContent;
        
        if (conditionA || conditionB) {
          clearInterval(checkInterval);
          const totalSeconds = Math.floor(elapsed / 1000);
          console.log(`[DeepSeek] ✅ 响应完成！用时: ${totalSeconds}秒，长度: ${currentContent.length}字符`);
          console.log(`[DeepSeek] 完成原因: ${conditionA ? '条件A(稳定+输入框可用)' : '条件B(稳定+有按钮)'}`);
          resolve();
        } else if (conditionC) {
          clearInterval(checkInterval);
          const totalSeconds = Math.floor(elapsed / 1000);
          console.warn(`[DeepSeek] ⚠️ 等待响应超时（${totalSeconds}秒）`);
          console.warn('[DeepSeek] 当前内容长度:', currentContent.length);
          
          if (currentContent.length > 0) {
            console.warn('[DeepSeek] 有部分内容，继续采集');
            resolve();
          } else {
            console.error('[DeepSeek] ❌ 超时且无内容，采集失败');
            reject(new Error('等待响应超时且无内容'));
          }
        }
      }, 500);  // 每500ms检查一次
    });
  }

  // 获取最新响应
  getLatestResponse() {
    const allMessages = document.querySelectorAll(this.selectors.aiMessage);
    if (allMessages.length === 0) return null;
    
    const lastMessage = allMessages[allMessages.length - 1];
    return this.extractMessageContent(lastMessage);
  }

  // 检查登录状态
  isLoggedIn() {
    console.log('\n========== [DeepSeek] 🔐 检查登录状态 ==========');
    
    // 方法1：检查URL（最准确）
    const url = window.location.href;
    console.log('[DeepSeek] 方法1 - URL检查:', url);
    
    if (url.includes('login') || url.includes('sign_in') || url.includes('sign-in')) {
      console.log('[DeepSeek] ❌ URL包含登录关键词 → 未登录');
      console.log('[DeepSeek] ============================================\n');
      return false;  // 在登录页，肯定未登录
    }
    console.log('[DeepSeek] ✓ URL不包含登录关键词');
    
    // 方法2：检查是否有输入框（已登录才有）
    console.log('[DeepSeek] 方法2 - 输入框检查 (textarea)');
    const inputBox = document.querySelector('textarea');
    console.log('[DeepSeek]   找到输入框:', inputBox ? '是' : '否');
    if (inputBox) {
      console.log('[DeepSeek] ✅ 找到输入框 → 已登录');
      console.log('[DeepSeek] ============================================\n');
      return true;
    }
    
    // 方法2.5：检查DeepSeek特有的输入区域
    console.log('[DeepSeek] 方法2.5 - 检查输入区域容器');
    const inputArea = document.querySelector('[class*="input"], [class*="Input"], [placeholder*="问"], [placeholder*="Ask"]');
    console.log('[DeepSeek]   找到输入区域:', inputArea ? '是' : '否');
    if (inputArea) {
      console.log('[DeepSeek] ✅ 找到输入区域 → 已登录');
      console.log('[DeepSeek] ============================================\n');
      return true;
    }
    
    // 方法3：检查是否有消息（已登录才能看到）
    console.log('[DeepSeek] 方法3 - 消息检查 (.ds-message)');
    const messages = document.querySelectorAll('.ds-message');
    console.log('[DeepSeek]   消息数量:', messages.length);
    if (messages.length > 0) {
      console.log('[DeepSeek] ✅ 找到消息 → 已登录');
      console.log('[DeepSeek] ============================================\n');
      return true;
    }
    
    // 方法4：检查发送按钮
    console.log('[DeepSeek] 方法4 - 发送按钮检查');
    const sendBtn = document.querySelector('div[role="button"][aria-label*="Send"], div[role="button"][aria-label*="发送"], button[aria-label*="Send"], button[aria-label*="发送"]');
    console.log('[DeepSeek]   找到发送按钮:', sendBtn ? '是' : '否');
    if (sendBtn) {
      console.log('[DeepSeek] ✅ 找到发送按钮 → 已登录');
      console.log('[DeepSeek] ============================================\n');
      return true;
    }
    
    // 方法5：检查是否有头像
    console.log('[DeepSeek] 方法5 - 用户头像检查');
    const userAvatar = document.querySelector('[class*="avatar"], [class*="Avatar"], [class*="user-icon"]');
    console.log('[DeepSeek]   找到头像:', userAvatar ? '是' : '否');
    if (userAvatar) {
      console.log('[DeepSeek] ✅ 找到头像 → 已登录');
      console.log('[DeepSeek] ============================================\n');
      return true;
    }
    
    // 方法6：检查是否有聊天容器
    console.log('[DeepSeek] 方法6 - 聊天容器检查');
    const chatContainer = document.querySelector('main, [role="main"], [class*="chat-container"]');
    console.log('[DeepSeek]   找到聊天容器:', chatContainer ? '是' : '否');
    const hasMainContent = chatContainer && chatContainer.children.length > 0;
    console.log('[DeepSeek]   容器有内容:', hasMainContent ? '是' : '否');
    if (hasMainContent) {
      console.log('[DeepSeek] ✅ 找到聊天容器且有内容 → 已登录');
      console.log('[DeepSeek] ============================================\n');
      return true;
    }
    
    // 方法7：检查是否有登录按钮（反向检测）
    console.log('[DeepSeek] 方法7 - 登录按钮检查（反向）');
    const loginBtn = document.querySelector('button[class*="login"], a[href*="login"], [class*="sign-in"]');
    console.log('[DeepSeek]   找到登录按钮:', loginBtn ? '是（说明未登录）' : '否（可能已登录）');
    if (loginBtn) {
      console.log('[DeepSeek] ❌ 找到登录按钮 → 未登录');
      console.log('[DeepSeek] ============================================\n');
      return false;
    }
    
    // 默认：如果在聊天页面，认为已登录
    console.log('[DeepSeek] 方法8 - 域名默认判断');
    const isDeepSeekChatDomain = url.includes('chat.deepseek.com');
    const notLoginPage = !url.includes('login');
    console.log('[DeepSeek]   是DeepSeek聊天域名:', isDeepSeekChatDomain);
    console.log('[DeepSeek]   不是登录页:', notLoginPage);
    
    const result = isDeepSeekChatDomain && notLoginPage;
    console.log('[DeepSeek]', result ? '✅' : '❌', '默认判断结果:', result ? '已登录' : '未登录');
    console.log('[DeepSeek] ============================================\n');
    
    return result;
  }
  
  // 🔧 调试功能：重置所有采集标记（用于测试）
  resetCollectionMarkers() {
    console.log('[DeepSeek] 🧹 重置所有采集标记...');
    const marked = document.querySelectorAll('[data-collected="true"]');
    console.log('[DeepSeek] 找到', marked.length, '个已标记的元素');
    
    marked.forEach((el, index) => {
      el.removeAttribute('data-collected');
      console.log(`[DeepSeek] ✓ 移除标记 ${index + 1}/${marked.length}`);
    });
    
    console.log('[DeepSeek] ✅ 所有标记已重置');
  }
  
  // 🔧 调试功能：查看当前页面状态
  debugPageStatus() {
    console.log('\n========== [DeepSeek] 页面状态调试 ==========');
    console.log('[DeepSeek] URL:', window.location.href);
    console.log('[DeepSeek] 已登录:', this.isLoggedIn());
    
    const userContainers = document.querySelectorAll('[class*="_9663"]');
    const aiContainers = document.querySelectorAll('[class*="_4f9bf79"]');
    const allMessages = document.querySelectorAll('[class*="ds-message"]');
    const markedMessages = document.querySelectorAll('[data-collected="true"]');
    
    console.log('[DeepSeek] 用户问题容器:', userContainers.length);
    console.log('[DeepSeek] AI回答容器:', aiContainers.length);
    console.log('[DeepSeek] 所有ds-message:', allMessages.length);
    console.log('[DeepSeek] 已标记的消息:', markedMessages.length);
    
    console.log('[DeepSeek] 任务上下文:');
    console.log('  - currentTaskId:', this.currentTaskId);
    console.log('  - currentQuestionId:', this.currentQuestionId);
    console.log('  - isCollecting:', this.isCollecting);
    
    console.log('[DeepSeek] ========================================\n');
  }

  // 🔧 新增：详细的调试分析工具
  debugMessageMatching() {
    console.log('\n========== [DeepSeek] 🔍 消息匹配调试分析 ==========');
    
    // 1. 当前状态
    console.log('[DeepSeek] 📊 当前状态:');
    console.log('  - currentSendingQuestion:', this.currentSendingQuestion ? `"${this.currentSendingQuestion.substring(0, 50)}..."` : 'null');
    console.log('  - messageIndexBeforeSend:', this.messageIndexBeforeSend);
    console.log('  - currentTaskId:', this.currentTaskId);
    console.log('  - currentQuestionId:', this.currentQuestionId);
    
    // 2. 所有消息分析
    const allMessages = Array.from(document.querySelectorAll('.ds-message'));
    console.log(`[DeepSeek] 📝 页面总消息数: ${allMessages.length}`);
    
    if (allMessages.length === 0) {
      console.warn('[DeepSeek] ⚠️ 没有找到任何消息');
      return;
    }
    
    // 3. 分类消息
    const userMessages = [];
    const aiMessages = [];
    
    allMessages.forEach((msg, index) => {
      const hasMarkdown = msg.querySelector('.ds-markdown') !== null;
      const hasErrorContainer = msg.querySelector('[class*="_60a11b2"]') !== null;
      const isCollected = msg.dataset.collected === 'true';
      const preview = msg.textContent.substring(0, 50).replace(/\n/g, ' ').trim();
      
      if (hasMarkdown || hasErrorContainer) {
        aiMessages.push({ element: msg, index, isCollected, hasMarkdown, hasErrorContainer });
        const type = hasErrorContainer ? 'AI错误' : 'AI正常';
        console.log(`[DeepSeek]   [${index}] ${type} | 已采集:${isCollected?'✅':'❌'} | 内容: ${preview}...`);
      } else {
        userMessages.push({ element: msg, index, isCollected });
        console.log(`[DeepSeek]   [${index}] 用户 | 已采集:${isCollected?'✅':'❌'} | 内容: ${preview}...`);
      }
    });
    
    console.log(`[DeepSeek] 📊 分类结果: 用户消息 ${userMessages.length} 个, AI消息 ${aiMessages.length} 个`);
    
    // 4. 测试策略0（内容匹配）
    if (this.currentSendingQuestion) {
      console.log('[DeepSeek] 🎯 测试策略0（内容匹配）:');
      console.log('  当前发送的问句:', `"${this.currentSendingQuestion}"`);
      
      let foundMatch = false;
      for (let i = userMessages.length - 1; i >= 0; i--) {
        const userContent = this.extractMessageContent(userMessages[i].element);
        const isMatch = userContent === this.currentSendingQuestion;
        console.log(`  [${userMessages[i].index}] 用户消息: "${userContent}" | 匹配:${isMatch?'✅':'❌'}`);
        
        if (isMatch && !foundMatch) {
          foundMatch = true;
          // 找对应的AI消息
          for (let j = 0; j < aiMessages.length; j++) {
            if (aiMessages[j].index > userMessages[i].index) {
              const messageType = aiMessages[j].hasErrorContainer ? '错误消息' : '正常消息';
              console.log(`    -> 对应的AI消息[${aiMessages[j].index}]: ${messageType} | 已采集:${aiMessages[j].isCollected?'✅':'❌'}`);
              break;
            }
          }
        }
      }
      
      if (!foundMatch) {
        console.warn('[DeepSeek] ⚠️ 策略0失败：没有找到匹配的用户消息');
      }
    } else {
      console.log('[DeepSeek] ℹ️ 策略0跳过：currentSendingQuestion 为空');
    }
    
    // 5. 测试策略1（索引比较）
    if (this.messageIndexBeforeSend >= 0) {
      console.log('[DeepSeek] 🎯 测试策略1（索引比较）:');
      console.log(`  基准索引: ${this.messageIndexBeforeSend}`);
      
      let foundNew = false;
      for (let i = aiMessages.length - 1; i >= 0; i--) {
        const isNewer = aiMessages[i].index > this.messageIndexBeforeSend;
        const messageType = aiMessages[i].hasErrorContainer ? '错误消息' : '正常消息';
        console.log(`  [${aiMessages[i].index}] AI消息: ${messageType} | 索引>基准:${isNewer?'✅':'❌'} | 已采集:${aiMessages[i].isCollected?'✅':'❌'}`);
        
        if (isNewer && !foundNew) {
          foundNew = true;
          console.log(`    -> 策略1会选择这个AI消息`);
        }
      }
      
      if (!foundNew) {
        console.warn('[DeepSeek] ⚠️ 策略1失败：没有找到索引更大的AI消息');
      }
    } else {
      console.log('[DeepSeek] ℹ️ 策略1跳过：messageIndexBeforeSend < 0');
    }
    
    // 6. 测试策略2（未采集消息）
    console.log('[DeepSeek] 🎯 测试策略2（未采集消息）:');
    let foundUncollected = false;
    for (let i = aiMessages.length - 1; i >= 0; i--) {
      const messageType = aiMessages[i].hasErrorContainer ? '错误消息' : '正常消息';
      console.log(`  [${aiMessages[i].index}] AI消息: ${messageType} | 已采集:${aiMessages[i].isCollected?'✅':'❌'}`);
      
      if (!aiMessages[i].isCollected && !foundUncollected) {
        foundUncollected = true;
        console.log(`    -> 策略2会选择这个AI消息`);
      }
    }
    
    if (!foundUncollected) {
      console.log('[DeepSeek] ℹ️ 策略2：所有AI消息都已采集');
    }
    
    console.log('[DeepSeek] ========== 调试分析完成 ==========\n');
  }

  // 🔧 新增：模拟提取对话（不实际保存）
  debugExtractConversation() {
    console.log('\n========== [DeepSeek] 🧪 模拟提取对话 ==========');
    
    try {
      const conversation = this.extractConversation();
      if (conversation) {
        console.log('[DeepSeek] ✅ 提取成功:');
        console.log('  用户问题:', conversation.userMessage);
        console.log('  AI回答长度:', conversation.aiResponse ? conversation.aiResponse.length : 0);
        console.log('  AI回答预览:', conversation.aiResponse ? conversation.aiResponse.substring(0, 100) + '...' : 'null');
        console.log('  是否错误:', conversation.isError ? '是⚠️' : '否✅');
        console.log('  错误信息:', conversation.errorMessage || '无');
      } else {
        console.error('[DeepSeek] ❌ 提取失败');
      }
    } catch (e) {
      console.error('[DeepSeek] ❌ 提取异常:', e);
    }
    
    console.log('[DeepSeek] ========== 模拟完成 ==========\n');
  }

  // 🔧 新增：详细分析消息匹配问题的调试工具
  debugMessageMatchingDetailed() {
    console.log('\n========== [DeepSeek] 🔍 详细消息匹配分析 ==========');
    
    // 1. 当前状态
    console.log('[DeepSeek] 📊 当前状态:');
    console.log('  - currentSendingQuestion:', this.currentSendingQuestion ? `"${this.currentSendingQuestion.substring(0, 50)}..."` : 'null');
    console.log('  - messageIndexBeforeSend:', this.messageIndexBeforeSend);
    console.log('  - currentTaskId:', this.currentTaskId);
    console.log('  - currentQuestionId:', this.currentQuestionId);
    
    // 2. 所有消息分析
    const allMessages = Array.from(document.querySelectorAll('.ds-message'));
    console.log(`[DeepSeek] 📝 页面总消息数: ${allMessages.length}`);
    
    if (allMessages.length === 0) {
      console.warn('[DeepSeek] ⚠️ 没有找到任何消息');
      return;
    }
    
    // 3. 详细分析每个消息
    console.log('[DeepSeek] 📋 详细消息分析:');
    allMessages.forEach((msg, index) => {
      const hasMarkdown = msg.querySelector('.ds-markdown') !== null;
      const hasErrorContainer = msg.querySelector('[class*="_60a11b2"]') !== null;
      const isCollected = msg.dataset.collected === 'true';
      const preview = msg.textContent.substring(0, 50).replace(/\n/g, ' ').trim();
      
      let messageType = '用户';
      if (hasMarkdown) messageType = 'AI正常';
      if (hasErrorContainer) messageType = 'AI错误';
      
      console.log(`[DeepSeek]   [${index}] ${messageType} | 已采集:${isCollected?'✅':'❌'} | 内容: ${preview}...`);
      
      // 如果是AI消息，显示更多信息
      if (hasMarkdown || hasErrorContainer) {
        const content = this.extractMessageContent(msg);
        console.log(`[DeepSeek]      -> 提取内容长度: ${content.length}`);
        console.log(`[DeepSeek]      -> 内容预览: ${content.substring(0, 100)}...`);
      }
    });
    
    // 4. 策略分析
    console.log('[DeepSeek] 🎯 策略分析:');
    
    // 策略0分析
    if (this.currentSendingQuestion) {
      console.log('[DeepSeek] 策略0（内容匹配）:');
      console.log('  当前发送的问句:', `"${this.currentSendingQuestion}"`);
      
      let foundMatch = false;
      for (let i = allMessages.length - 1; i >= 0; i--) {
        const msg = allMessages[i];
        const hasMarkdown = msg.querySelector('.ds-markdown') !== null;
        const hasErrorContainer = msg.querySelector('[class*="_60a11b2"]') !== null;
        
        // 跳过AI消息
        if (hasMarkdown || hasErrorContainer) continue;
        
        const userContent = this.extractMessageContent(msg);
        const isMatch = userContent === this.currentSendingQuestion;
        console.log(`  [${i}] 用户消息: "${userContent}" | 匹配:${isMatch?'✅':'❌'}`);
        
        if (isMatch && !foundMatch) {
          foundMatch = true;
          // 找对应的AI消息
          for (let j = i + 1; j < allMessages.length; j++) {
            const aiMsg = allMessages[j];
            const aiHasMarkdown = aiMsg.querySelector('.ds-markdown') !== null;
            const aiHasErrorContainer = aiMsg.querySelector('[class*="_60a11b2"]') !== null;
            
            if (aiHasMarkdown || aiHasErrorContainer) {
              const aiContent = this.extractMessageContent(aiMsg);
              const aiType = aiHasErrorContainer ? '错误消息' : '正常消息';
              console.log(`    -> 对应的AI消息[${j}]: ${aiType} | 已采集:${aiMsg.dataset.collected === 'true'?'✅':'❌'}`);
              console.log(`    -> AI内容长度: ${aiContent.length}`);
              console.log(`    -> AI内容预览: ${aiContent.substring(0, 100)}...`);
              break;
            }
          }
        }
      }
      
      if (!foundMatch) {
        console.warn('[DeepSeek] ⚠️ 策略0失败：没有找到匹配的用户消息');
      }
    } else {
      console.log('[DeepSeek] 策略0跳过：currentSendingQuestion 为空');
    }
    
    // 策略1分析
    if (this.messageIndexBeforeSend >= 0) {
      console.log('[DeepSeek] 策略1（索引比较）:');
      console.log(`  基准索引: ${this.messageIndexBeforeSend}`);
      
      let foundNew = false;
      for (let i = allMessages.length - 1; i >= 0; i--) {
        const msg = allMessages[i];
        const hasMarkdown = msg.querySelector('.ds-markdown') !== null;
        const hasErrorContainer = msg.querySelector('[class*="_60a11b2"]') !== null;
        
        if (hasMarkdown || hasErrorContainer) {
          const isNewer = i > this.messageIndexBeforeSend;
          const messageType = hasErrorContainer ? '错误消息' : '正常消息';
          console.log(`  [${i}] AI消息: ${messageType} | 索引>基准:${isNewer?'✅':'❌'} | 已采集:${msg.dataset.collected === 'true'?'✅':'❌'}`);
          
          if (isNewer && !foundNew) {
            foundNew = true;
            console.log(`    -> 策略1会选择这个AI消息`);
          }
        }
      }
      
      if (!foundNew) {
        console.warn('[DeepSeek] ⚠️ 策略1失败：没有找到索引更大的AI消息');
      }
    } else {
      console.log('[DeepSeek] 策略1跳过：messageIndexBeforeSend < 0');
    }
    
    console.log('[DeepSeek] ========== 详细分析完成 ==========\n');
  }
}

// 初始化
const collector = new DeepSeekCollector();
collector.init();

console.log('[DeepSeek] 内容脚本已加载');

// 🔧 开发调试：添加全局访问（可在控制台手动调用）
window.deepseekCollector = collector;
console.log('[DeepSeek] 💡 调试提示：');
console.log('  - 查看状态：deepseekCollector.debugPageStatus()');
console.log('  - 消息匹配分析：deepseekCollector.debugMessageMatching()');
console.log('  - 详细消息匹配分析：deepseekCollector.debugMessageMatchingDetailed()');
console.log('  - 模拟提取：deepseekCollector.debugExtractConversation()');
console.log('  - 重置标记：deepseekCollector.resetCollectionMarkers()');
console.log('  - 手动采集：deepseekCollector.extractConversation()');

